Les boucles C#

ACDC 2027


Introduction
Durant ce mémo, nous allons apprendre à utiliser les boucles en C#.

Les boucles sont des structures permettant de répéter une ou plusieurs instructions plusieurs fois. Il existe quatre types principaux de boucles en C# :
  • la boucle while
  • la boucle do-while
  • la boucle for
  • la boucle foreach
Voyons comment les utiliser.

Format
while (condition)
{
  // your code here
}

La boucle while est une boucle qui répète une instruction ou un bloc d'instructions tant qu'une condition est vraie.
La condition est vérifiée avant l'exécution du bloc d'instructions. Si la condition est fausse, le bloc d'instructions ne sera pas exécuté.

Prenons un exemple pour mieux comprendre. Imaginons que nous voulons afficher les nombres de 1 à 5. Voici comment nous pourrions le faire en utilisant une boucle while :

Exemple 1
int i = 1;
while (i <= 5)
{
  Console.WriteLine(i);
  i++;
}

Décomposons cet exemple :
Avant la boucle, i = 1.
Première itération, i = 1, 1 <= 5 est vrai, donc nous affichons 1 et incrémentons i de 1.
Deuxième itération, i = 2, 2 <= 5 est vrai, donc nous affichons 2 et incrémentons i de 1.
Troisième itération, i = 3, 3 <= 5 est vrai, donc nous affichons 3 et incrémentons i de 1.
Quatrième itération, i = 4, 4 <= 5 est vrai, donc nous affichons 4 et incrémentons i de 1.
Cinquième itération, i = 5, 5 <= 5 est vrai, donc nous affichons 5 et incrémentons i de 1.
Sixième itération, i = 6, 6 <= 5 est faux, donc nous sortons de la boucle.

Format
do
{
  // your code here
} while (condition);

La boucle do-while est une boucle qui répète une instruction ou un bloc d'instructions tant qu'une condition est vraie.
La condition est vérifiée après l'exécution du bloc d'instructions. Cela signifie que le bloc d'instructions sera exécuté au moins une fois, même si la condition est fausse.

Prenons un exemple pour mieux comprendre. Imaginons que nous voulons afficher les nombres de 1 à 5. Voici comment nous pourrions le faire en utilisant une boucle do-while :

Exemple 1
int i = 1;
do
{
  Console.WriteLine(i);
  i++;
} while (i <= 5);

Décomposons cet exemple :
Avant la boucle, i = 1.
Première itération, i = 1, nous affichons 1 et incrémentons i de 1.
Deuxième itération, i = 2, 2 <= 5 est vrai, donc nous affichons 2 et incrémentons i de 1.
Troisième itération, i = 3, 3 <= 5 est vrai, donc nous affichons 3 et incrémentons i de 1.
Quatrième itération, i = 4, 4 <= 5 est vrai, donc nous affichons 4 et incrémentons i de 1.
Cinquième itération, i = 5, 5 <= 5 est vrai, donc nous affichons 5 et incrémentons i de 1.
Sixième itération, i = 6, 6 <= 5 est faux, donc nous sortons de la boucle.


Prenons un autre exemple. Imaginons que i soit égal à 10. Voici comment nous pourrions le faire en utilisant une boucle do-while :

Exemple 2
int i = 10;
do
{
  Console.WriteLine(i);
  i++;
} while (i <= 5);

Décomposons cet exemple :
Avant la boucle, i = 10.
Première itération, i = 10, nous affichons 10 et incrémentons i de 1.
Deuxième itération, i = 11, 11 <= 5 est faux, donc nous sortons de la boucle.

Format
for (initialization; condition; increment)
{
  // your code here
}

La boucle for est une boucle qui répète une instruction ou un bloc d'instructions un nombre spécifique de fois.
Elle est souvent utilisée lorsqu'il est nécessaire de répéter une instruction un nombre spécifique de fois.

La boucle for est composée de trois parties :
  • l'initialisation : une instruction qui est exécutée une seule fois avant le début de la boucle
  • la condition : une expression booléenne qui est évaluée avant chaque itération de la boucle
  • l'incrémentation : une instruction qui est exécutée à la fin de chaque itération de la boucle

Prenons un exemple pour mieux comprendre. Imaginons que nous voulons afficher les nombres de 1 à 5. Voici comment nous pourrions le faire en utilisant une boucle for :

Exemple 1
for (int i = 1; i <= 5; i++)
{
  Console.WriteLine(i);
}

Décomposons cet exemple :
Avant la boucle, i = 1.
Première itération, i = 1, 1 <= 5 est vrai, donc nous affichons 1 et incrémentons i de 1.
Deuxième itération, i = 2, 2 <= 5 est vrai, donc nous affichons 2 et incrémentons i de 1.
Troisième itération, i = 3, 3 <= 5 est vrai, donc nous affichons 3 et incrémentons i de 1.
Quatrième itération, i = 4, 4 <= 5 est vrai, donc nous affichons 4 et incrémentons i de 1.
Cinquième itération, i = 5, 5 <= 5 est vrai, donc nous affichons 5 et incrémentons i de 1.
Sixième itération, i = 6, 6 <= 5 est faux, donc nous sortons de la boucle.

Format
foreach (type variable in collection)
{
  // your code here
}

La boucle foreach est une boucle qui répète une instruction ou un bloc d'instructions pour chaque élément d'une collection.
Elle est souvent utilisée pour parcourir des tableaux, des listes ou d'autres collections d'objets.

Prenons un exemple pour mieux comprendre. Imaginons que nous voulons afficher les éléments d'un tableau. Voici comment nous pourrions le faire en utilisant une boucle foreach :

Exemple 1
int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int number in numbers)
{
  Console.WriteLine(number);
}

Décomposons cet exemple :
Avant la boucle, numbers = { 1, 2, 3, 4, 5 }.
Première itération, number = 1, nous affichons 1.
Deuxième itération, number = 2, nous affichons 2.
Troisième itération, number = 3, nous affichons 3.
Quatrième itération, number = 4, nous affichons 4.
Cinquième itération, number = 5, nous affichons 5.
Sixième itération, la structure est vide,nous sortons donc de la boucle.

Prenons un autre exemple. Imaginons que nous voulons afficher les éléments d'une string. Voici comment nous pourrions le faire en utilisant une boucle foreach :

Exemple 2
string message = "ACDC";
foreach (char character in message)
{
  Console.WriteLine(character);
}

Décomposons cet exemple :
Avant la boucle, message = "ACDC".
Première itération, character = 'A', nous affichons A.
Deuxième itération, character = 'C', nous affichons C.
Troisième itération, character = 'D', nous affichons D.
Quatrième itération, character = 'C', nous affichons C.
Cinquième itération, la structure est vide,nous sortons donc de la boucle.


This page and all subpages are for internal use at EPITA only.
The use of this document must abide by the following rules:
Copyright © 2024-2025 - EPITA